/* var json = '{"name":"z","age":18}';
json=JSON.parse(json)
alert(json.name)
var js={"name":"zs","age":18}
js=JSON.stringify(js)
alert(js)
 */
/* function fun(){
     alert(this.name)
}
person1={
    name:"zs",
    age:20,
    fun
}
person1.fun()
function createPerson(name,age){
    var person=new Person()
    person.name=name
    person.age=age
    person.fn=function(){
        alert(this.name)
    }
    return person
} */
/* const fs = require('fs');
const { resolve } = require('path');
const { Generator } = require('webpack');
const readFile = function (fileName){
    return new Promise(function (resolve,reject){
        fs.readFile(fileName,function(error,data){
            if(error) return reject(error);
            resolve(data)
        })
    })
}
const gen = function * (){
    const f1=yield readFile('/etc/fstab');
    const f2 = yield readFile('/etc/shells');
    console.log(f1.toString());
    console.log(f2.toString())
} */
/**
 *上面的代码改为async函数，就是下面这样 
 */
/* const asyncReadFile = async function(){
    const f1=await readFile('/etc/fstab');
    const f2=await readFile('/etc/shells');
    console.log(f1.toString());
    console.log(f2.toString());
}
一比较会发现，async函数就是将Generator函数的星号（*）替换成async,将
yield替换成await，仅此而已
async函数对Generator函数的改进,体现在以下四点
1.内置执行器
Generator函数的执行必须靠执行器，所以才有了co模块，而async函数自带执行器
。也就是说，async函数的执行，与普通函数一模一样，只要一行
asyncReadFile();
上面的代码调用了asyncReadFile函数，然后他就会自动执行，输出最后结果。
这完全不像Generator函数，需要调用next 方法，或者co模块, 
async表示函数有异步操作，await表示紧跟在后面的表达式需要等待结果
3.更广的适用性
async函数的返回值是Promise对象,这比Generator函数的返回值是Itertor对象方便
多了,你可以适用then方法指定下一步的操作
进一步说，async函数完全可以看做多个异步操作，包装成一个Promise对象，而
await命令就是内部then命令的语法糖

*/
/* async function getStockPriceByName(name){
    const symbol = await getStockSymbol(name);
    const stockPrice = await getStockPriceByName(symbol);
    return stockPrice;
}
getStockPriceByName('goog').then(function(result){
    console.log(result);
})
上面代码是一个获取股票报价的函数，函数前面的async关键字，表明该函数内部
有异步操作。调用该函数时，会立即返回一个Promise对象。
下面是另一个例子，指定多少毫秒后输出一个值
function timeout(ms){
    return new Promise((resolve)=>{
        setTimeout(resolve,ms)
    })
}
async function asyncPrint(value,ms){
    await timeout(ms);
    console.log(value);
}
asyncPrint('hello world',50);

async function timeout(ms){
    await new Promise((resolve)=>{
        setTimeout(resolve,ms)
    })
}
async function asyncPrint(value,ms){
    await timeout(ms);
    console.log(value)
}
asyncPrint("hello world",50)

async function foo(){
}
const foo = async function(){}
对象的方法
let obj={async foo(){}};
obj.foo().then(...)
class Storage{
    constructor(){
        this.cachePromise = caches.open('avatars');
    }
    async getAvatar(name){
        const cache = await this.cachePromise;
        return cache.match(`/avatars/${name}.jpg`)

    }
}
const Storage = new Storage();
Storage.getAvatar('jake').then(...);
箭头函数
const foo=async ()=>{};
返回Promise对象
async 函数返回一个Promise对象
async 函数内部return语句返回的值，会成为then方法回调函数的参数。
async function f(){
    return 'hello world';
}
f().then(v=>console.log(v))
上面代码中，函数f内部return命令返回的值，会被then方法回调函数接收到
async function f(){
    throw new Error('出错了');
}
async函数内部抛出错误,会导致返回的Promise对象变为reject转态。抛出的错误对象
会被catch方法回调函数接收到
async function f(){
    throw new Error('出错了');
}
f().then(
    v=>console.log('resolve',v),
    e=>console.log('reject',e)
)
Promise对象的转态变化
async 函数返回的Promise对象，必须等到内部所以的 */
/* function * gen(){
    yield 111;
    yield 222;
    yield 333;
}
let iterator = gen();
console.log(iterator.next());
console.log(iterator.next())
console.log(iterator.next())
console.log(iterator.next()) */
/* const p = new Promise((resolve,reject)=>{
    setTimeout(()=>{
      //  resolve("成功")
      reject("失败")
    },2000)
})
p.then((value)=>{
    console.log(value)
},(error)=>{
    console.error(error)
}) */
/* const fs = require('fs')
const p =new Promise(function(resolve,reject){
    fs.readFile("./url",(err,data)=>{
        if(err) reject(err);
        resolve(data)
    })
})
p.then(function(value){
    console.log(value.toString());
},function(reason){

}) */
const p= new Promise((resolve,reject)=>{
    var xhr = new XMLHttpRequest();
    xhr.open("Get","./ulr");
    xhr.send();
    xhr.onreadystatechange=function(){
        if(xhr.readyState==4 && xhr.status==200){
            resolve(xhr.responseText);
        }else{
            reject(xhr.status)
        }
    }
    p.then(function(value){
        console.log(value)
    })
})